﻿const Router = require('koa-router');
const axios = require('axios');
const router = new Router();
const returns = require('../unit');
const userModel = require('../model/user');
const prodModel = require('../model/prod');
const addrModel = require('../model/address');
const bannerModel = require('../model/banner');
const seckillModel = require('../model/secKill');
const cartModel = require('../model/cart');
const orderModel = require('../model/order');
// const createToken = require('../uploadImg/createToken');
const ali = require('../aliPay/index');
// const mongoose = require('mongoose');
// const validMsg = require('../shortMsg');
router.get('/validCode', async (ctx, next) => {
    let currentTime = new Date().getTime();
    if(ctx.session.validCodeMaxAge) {
        if(currentTime - ctx.session.validCodeMaxAge <= 60000) {
            ctx.body = returns(1001, `请求过于频繁请，请稍后再试`);
        } else {
            let _validCode = Math.floor(Math.random()*1000000)+'';
            ctx.session.validCode = _validCode;
            ctx.body = returns(1002, `验证码发送成功`, _validCode);
        }
    } else {
        let _validCode = Math.floor(Math.random()*1000000)+'';
        ctx.session.validCodeMaxAge = currentTime;
        ctx.session.validCode = _validCode;
        ctx.body = returns(1002, `验证码发送成功`, _validCode);
    }
    await next();
});
//用户注册
router.put('/register',async(ctx, next)=>{
    let {phoneNumber, validCode, password} = ctx.request.body;
    if (validCode === ctx.session.validCode) {
        let registed = await userModel.find({ phoneNumber });
        if (!!registed.length) {
            ctx.body = returns(2004, '该手机号已经注册过了，请登录');
        } else {
            if (/^1[35789]\d{9}$/.test(phoneNumber)) {
                await userModel.create({ phoneNumber, password})
                    .then(data=>{
                        ctx.body = returns(2001, '注册成功', data);
                    }).
                    catch(error=>{
                        ctx.body = returns(2002, '注册失败', error);
                    })
            } else {
                ctx.body = returns(3004, '手机号不合法');
            }
        }
    } else {
        ctx.body = returns(2003, '验证码不正确');
    }
    await next();
});
//用户登录
router.post('/login',async(ctx, next)=>{
    let {phoneNumber, password} = ctx.request.body;
    if(/^1[35789]\d{9}$/.test(phoneNumber)) {
        await userModel.findOne({phoneNumber}).then(data=>{
            if(data.password === password){
                ctx.session.uid = data._id;
                ctx.body = returns(3001, '登录成功', data);
            }else{
                ctx.body = returns(3002, '密码不正确');
            }
        }).catch(error=>{
            ctx.body = returns(3003, '该手机号还未注册', error);
        });
    } else {
        ctx.body = returns(3004, '手机号不合法');
    }
    await next();
});
//用户注销
router.delete('/user',async(ctx, next)=>{
    ctx.session = {};
    ctx.body = returns(10000, '注销成功');
    await next();
});
//增加收货地址
router.put('/addr', async(ctx, next)=>{
    let {receiver, location, details, phoneNumber} = ctx.request.body;
    await addrModel.create({receiver, location, details, phoneNumber,  uid: ctx.session.uid})
                        .then(data =>{
                            ctx.body = returns(4001, '收货地址保存成功', data);
                        })
                        .catch(()=>{
                             ctx.body = returns(4003, '参数不正确' );
                        });
    await next();
});
//设置默认地址
router.post('/defaultAddr', async (ctx, next)=>{
    let {addrid} = ctx.request.body;
    if(addrid) {
        await addrModel.findOneAndUpdate({uid: ctx.session.uid, isDefault: true},{isDefault: false})
        .then(async data => {
            await addrModel.findOneAndUpdate({uid: ctx.session.uid, _id: addrid}, {isDefault: true})
            .then(data=>{
                ctx.body = {
                    code: '10001',
                    msg: '设置默认地址成功',
                    data
                }
            })
            .catch(error=>{
                ctx.body = {
                    code: '10002',
                    msg: '服务器错误',
                    data: error
                }
            });
        })
        .catch(error=>{
            ctx.body = {
                code: '10002',
                msg: '服务器错误',
                data: error
            }
        });
    }else{
        ctx.body = {
            code: '10003',
            msg: 'addrid不存在或则不合法',
            data: []
        }
    }
    await next();
});
//查询收货地址
router.get('/addr', async(ctx, next)=>{
    if(ctx.session.uid){
        await addrModel.find({uid: ctx.session.uid})
            .then(data=>{
                ctx.body = returns(5001, '地址查询完成', data);
            })
            .catch(()=>{
                ctx.body = returns(5003, '数据库写入失败');
            })
    }else{
        ctx.body = returns(5004, '没有权限');
    }
    await next();
});
// 删除收获地址
router.delete('/addr', async(ctx, next)=>{
   let {addrid} = ctx.request.query;
   if(addrid){
       await addrModel.remove({_id: addrid})
           .then(data=>{
               ctx.body = returns(1, '该地址删除成功')
           })
           .catch(()=>{
               ctx.body = returns(-1, '删除失败');
           })
   }else {
       ctx.body = returns(-1, '删除失败,addrid是必须的');
   }
   await next();
});
// 更新收货地址
router.post('/addr', async(ctx, next) => {
    let {addrid, receiver, phoneNumber, location, details} = ctx.request.body;
    await addrModel.findOneAndUpdate({_id: addrid, uid: ctx.session.uid},{receiver, phoneNumber, location, details})
    .then(data=>{
        ctx.body = {
            code: 8000,
            msg: '地址更新成功',
            data: data
        };
    })
    .catch(error=>{
        ctx.body = {
            code: 8001,
            msg: '服务器错误',
            data: []
        };
    })
    await next();
})

// 用户获得商品
router.get('/prod', async(ctx, next)=>{
    let {prodCategory, prodSubClass, startIndex, count} = ctx.request.query;
    await prodModel.find({prodCategory, prodSubClass}).skip(+startIndex).limit(+count)
    .then(data=>{
        ctx.body = returns(10100, '商品数据返回成功', data);
    })
    .catch(error=>{
        ctx.body = returns(10101, '商品数据返回失败', error);
    });
    await next();
});
// 获取推荐商品
router.get('/recommend', async(ctx, next)=>{
    await prodModel.aggregate( [ { $sample: { size: 10 } } ] )
        .then(data=>{
            ctx.body = returns(1, '获取推荐商品成功', data)
        })
        .catch(error=>{
            ctx.body = returns(-1, error.name, error.message);
        });
    await next();
});

// 获取轮播banner图片
router.get('/banner', async(ctx, next)=>{
    await bannerModel.find({isActive: true})
    .then(data=>{
        ctx.body = returns(10020, '获取banner数据成功', data);
    })
    .catch(error=>{
        ctx.body = returns(10021, '获取banner数据失败', error);
    });
    await next();
});

// 获取秒杀商品
router.get('/secKill', async(ctx, next)=>{
    let {count} = ctx.request.query;
    if(count){
        await seckillModel.find().limit(+count)
    .then(data=>{
        ctx.body = returns(10040, '获取秒杀成功', data);
    })
    .catch(error=>{
        ctx.body = returns(10041, '获取秒杀失败', error);
    })
    }else{
        await seckillModel.find()
    .then(data=>{
        ctx.body = returns(10040, '获取秒杀成功', data);
    })
    .catch(error=>{
        ctx.body = returns(10041, '获取秒杀失败', error);
    })
    }
    await next();
});

// 添加到购物车
router.put('/cart', async (ctx, next) => {
   let {prodid, num} = ctx.request.body;
   if(prodid && num) {
       await cartModel.findOne({prod: prodid, uid: ctx.session.uid, checked: false})
           .then(async data=>{
               await cartModel.update({prod: prodid, uid: ctx.session.uid}, {num: data.num + num})
                   .then(()=>{
                       ctx.body = returns(1,'添加到购物车成功');
                   })
                   .catch(error=>{
                       ctx.body = returns(-1, error.name, error.message);
                   });
           })
           .catch(async()=>{
               await cartModel.create({prod: prodid, num, uid: ctx.session.uid})
                   .then(()=>{
                       ctx.body = returns(1,'添加到购物车成功');
                   })
                   .catch(error=>{
                       ctx.body = returns(-1, error.name, error.message);
                   })
           });
   }else{
       ctx.body = returns(-1, '添加到购物车失败,商品id和商品数量是必须参数');
   }
   await next();
});
// 删除购物车商品
router.post('/delcart', async (ctx, next) => {
    let {cartids} = ctx.request.body;
    // console.log(cartids);
    // cartids 购物车id集合数组
    if(cartids) {
        await cartModel.remove({_id: {$in: cartids}, uid: ctx.session.uid})
            .then(()=>{
                ctx.body = returns(1,'删除购物车当前商品成功');
            })
            .catch(()=>{
                ctx.body = returns(-1, '删除购物车当前商品失败');
            })
    }else{
        ctx.body = returns(-1, '删除购物车当前商品失败,购物车id[cartid]是必须参数');
    }
    await next();
});
// 更新购物车商品状态
router.post('/cart', async (ctx, next) => {
    let {cartid, num} = ctx.request.body;
    if(cartid && num) {
        await cartModel.findOneAndUpdate({_id: cartid, uid: ctx.session.uid},{num})
            .then(()=>{
                ctx.body = returns(1,'购物车当前商品更新成功');
            })
            .catch((error)=>{
                ctx.body = returns(-1, error.name, error.message);
            })
    }else{
        ctx.body = returns(-1, '购物车当前商品更新失败,购物车id[cartid]和商品数量[num]必须参数');
    }
    await next();
});
// 获取购物车数据
router.get('/cart', async (ctx, next) => {
    await cartModel.find({uid: ctx.session.uid, checked: false}).populate('prod')
        .then(data=>{
            ctx.body = returns(1, '购物车数据获取成功', data);
        })
        .catch(error=>{
            ctx.body = returns(-1, '购物车数据获取失败', error);
        });
    await next();
});
// 获取购物车商品数量
router.get('/cartCount', async(ctx, next)=>{
    await cartModel.count({uid: ctx.session.uid, checked: false})
            .then(data=>{
                ctx.body = returns(1, '获取购物车商品总数成功', {cartCount: data});
            })
            .catch(error=>{
                ctx.body = returns(-1, error.name, error.message)
            });
    await next();
});
// 商品模糊搜索
router.get('/searchProd', async(ctx, next)=>{
   let {keyword} = ctx.request.query;
   console.log(keyword);
   if(keyword) {
       let keywordReg = new RegExp(keyword,'ig');
       console.log(keywordReg);
       let pageSize = 15;
       if (ctx.session.searchProdIndex) {
           ctx.session.searchProdIndex ++;
       } else {
           ctx.session.searchProdIndex = 0;
       }
       await prodModel.find({ $or: [
               { prodSubTitle: { $regex: keywordReg } },
               { prodSupTitle: { $regex: keywordReg } }
           ] })
           .skip(ctx.session.searchProdIndex * pageSize)
           .limit(pageSize)
           .select('-__v')
           .then(data=>{
               ctx.body = returns(1, `返回第${ctx.session.searchProdIndex + 1}业相关搜索数据`, data);
           })
           .catch(error=>{
               ctx.body = returns(1, error.name, error.message);
           });
   } else {
       ctx.body = returns(1, '请输入搜索关键字');
   }
    await next();
});


// 新建购物订单
router.put('/order', async (ctx, next)=>{
    let {carts, addr, payStatus} = ctx.request.body;
    // console.log(ctx.request.body);
    if(carts && addr && [-1, 0, 1, 2].indexOf(payStatus) > -1){
        await orderModel.create({
            uid: ctx.session.uid,
            carts,
            addr,
            payStatus
        })
            .then((data)=>{
                ctx.body = returns(1, '生成订单成功', data);
            })
            .catch(error=>{
                ctx.body = returns(-1, error.name, error.message);
            })
    } else {
        ctx.body = returns(-2, '参数不合法');
    }
    await next();
});
// 删除订单
router.delete('/order', async (ctx, next) => {
    let {orderid} = ctx.request.query;
    if(orderid) {
        await orderModel.findOneAndDelete({_id: orderid})
            .then(()=>{
                ctx.body = returns(1, '删除订单成功')
            })
            .catch(error=>{
                ctx.body = returns(-1, error.name, error.message);
            })
    }else {
        ctx.body = returns(-2, '参数不合法');
    }
    await next();
});
// 更新订单状态
router.post('/order', async (ctx, next)=>{
    let {orderid, payStatus} = ctx.request.body;
    await orderModel.findOneAndUpdate({_id: orderid}, {payStatus}).select('-__v')
        .then(data=>{
            ctx.body = returns(1, '更新数据成功')
        })
        .catch(error=>{
            ctx.body = returns(-1, error.name, error.message);
        });
    await next();
});
// 查询订单
router.get('/order', async (ctx, next) =>{
    let {payStatus} = ctx.request.query;
    if(['-1', '0', '1', '2'].indexOf(payStatus) > 0) {
        await orderModel.find({ uid: ctx.session.uid, payStatus}).populate({
            path: 'carts',
            select: '-uid -__v -_id',
            populate: {
                path: 'prod',
                select: '-isPublish -prodCategory -prodSubClass -__v -_id'
            }
        })
            .then(data=>{
                ctx.body = returns(1, '查询订单成功', data);
            })
            .catch(error=>{
                ctx.body = returns(-1, error.name, error.message);
            });
    }
    await next();
});


//结算 支付宝支付
router.post('/pay', async(ctx, next)=>{
    let {orderid} = ctx.request.body;
    console.log(`需支付订单编号${orderid}`);
    console.log(ctx.request.body);
    await orderModel.find({_id: orderid}).populate({
        path: 'carts',
        select: '-uid -__v -_id',
        populate: {
            path: 'prod',
            select: '-isPublish -prodCategory -prodImage -prodSubClass -prodSupTitle -prodSubTitle -__v -_id'
        }
    })
        .then(data=>{
            let allPrice = data[0].carts.reduce(function (prev, current, index, arr) {
                return prev + (+current.prod.currentPrice * current.num);
            }, 0);
            let pay_url = 'https://openapi.alipaydev.com/gateway.do?'+ali('快捷商城收款',orderid,allPrice);
            ctx.body = returns(1, '支付宝付款链接', pay_url);
        })
        .catch(error=>{
            ctx.body = returns(-1, error.name, error.message)
        });
    await next();
});
router.post('/paySuccess', async(ctx, next)=>{
    let {out_trade_no} = ctx.request.body;
    await orderModel.findOneAndUpdate({_id: out_trade_no},{payStatus: 1})
        .then(async data=>{
            await cartModel.updateMany({ _id: { $in: data.carts } }, {checked: true})
                .then(()=>{
                    ctx.body = 'success';
                })
                .catch(error=>{
                    console.log([error.name, error.message])
                })
        });
    await next();
});
















// //用户注册
// router.put('/api/user',async(ctx, next)=>{
//     let {telNumber, validCode, password} = ctx.request.body;
//     if(telNumber){
//         let _validCode = validMsg.validByShortMsg(telNumber);
//         ctx.session.telNumber = telNumber;
//         ctx.session.validCode = _validCode;
//         ctx.body = returns(1, `验证码已经发送到+86 ${telNumber}`);
//     }
//     if(validCode){
//         if(validCode === ctx.session.validCode){
//             await userModel.create({
//                 telNumber:ctx.session.telNumber,
//                 password
//             })
//                 .then(data=>{
//                     ctx.session.auth = data._id;
//                     ctx.body = returns(1, '注册成功', data);
//                 }).
//                 catch(error=>{
//                     ctx.body = returns(-1, '注册失败', error);
//                 })
//         }else {
//             ctx.body = returns(-1, '验证码不正确');
//         }
//     }
//     await next();
// });
// //用户登录
// router.post('/api/user',async(ctx, next)=>{
//     let {telNumber, password} = ctx.request.body;
//     await userModel.findOne({telNumber}).then(data=>{
//         if(data.password === password){
//             ctx.session.auth = data._id;
//             ctx.body = returns(1, '登录成功', data);
//         }else{
//             ctx.body = returns(-1, '密码不正确');
//         }
//     }).catch(error=>{
//         ctx.body = returns(-2, '数据库连接失败', error);
//     });
//     await next();
// });
// //用户注销
// router.delete('/api/user',async(ctx, next)=>{
//     ctx.session = {};
//     ctx.body = returns(1, '注销成功');
// });

// /*商品模块*/
// //获取商品列表
// router.get('/api/prod', async (ctx, next)=>{
//     //ctx.session.getCount?ctx.session.getCount++:(ctx.session.getCount = 1);
//     let {prodType, isPublish,  prodCount} = ctx.request.query;
//     if(prodType&&isPublish){
//         //console.log((ctx.session.getCount-1)* +prodCount)
//         //console.log((ctx.session.getCount-1)* +prodCount + +prodCount);
//         await prodModel.find({prodType, isPublish}).then(data=>{
//             ctx.body = returns(1, '商品列表请求成功', data);
//         }).catch(error =>{
//             ctx.body = returns(-1, '查询数据库失败', error);
//         })
//     }else if(isPublish){
//         await prodModel.find({isPublish}).then(data =>{
//             ctx.body = returns(1, '商品列表请求成功', data);
//         }).catch(error =>{
//             ctx.body = returns(-1, '查询数据库失败', error);
//         })
//     }
//     await next();
// });
// /*商品详情模块*/
// //获取对应商品详情
// const vArr = ['https://cloud.video.taobao.com/play/u/2935611745/p/1/e/6/t/1/50228290820.mp4',
//                 'https://cloud.video.taobao.com/play/u/2627871549/p/1/e/6/t/1/50011420273.mp4',
//                 'https://cloud.video.taobao.com/play/u/2616533851/p/1/e/6/t/1/50177124212.mp4',
//     'https://cloud.video.taobao.com/play/u/3857921561/p/1/e/6/t/1/50202476949.mp4',
//     'https://cloud.video.taobao.com/play/u/773893322/p/1/e/6/t/1/50224480333.mp4',
//     'https://cloud.video.taobao.com/play/u/3362961389/p/1/e/6/t/1/50212060595.mp4',
//     'https://cloud.video.taobao.com/play/u/2175336361/p/1/e/6/t/1/50208080234.mp4',
//     'https://cloud.video.taobao.com/play/u/3311258085/p/1/e/6/t/1/50111030679.mp4',
//     'https://cloud.video.taobao.com/play/u/3311258085/p/1/e/6/t/1/50111030679.mp4'

// ];
// router.post('/api/prodDetails', async (ctx, next)=>{
//     function random(a, b){
//         return ~~((b - a)*Math.random() + a);
//     }
//     console.log(random(1, 6),random(0, 40));
//     await prodModel.find().limit(random(1, 6)).skip(random(0, 40))
//         .then(data=>{
//             ctx.body = returns(1,'ok',{
//                 vedio:vArr[random(0,9)],
//                 associateProd:data,
//                 star:random(1, 5)
//             });
//         })
//         .catch(error=>{
//             return returns(-1,'error');
//         });
//     await next();
// });
// /*购物车模块*/
// //当前用户添加商品到购物车
// router.put('/api/cart', async (ctx, next)=>{
//     let {pid} = ctx.request.body;
//     if(pid){
//         // await cartModel.updata({uid: ctx.session.auth, pid}, {num}, {upsert:true, setDefaultsOnInsert:1})
//         //     .then(data=>{
//         //         ctx.body = returns(1, 'success', data);
//         //     })
//         //     .catch(error=>{
//         //         ctx.body = returns(-1, 'error', data);
//         //     })
//         await cartModel.findOne({uid: ctx.session.auth, pid})
//             .then( async data=>{
//                 let num = data.num + 1;
//                 await cartModel.update({uid: ctx.session.auth, pid},{num:num})
//                     .then(data=>{
//                         ctx.body = returns(1, '添加到购物车成功', data);
//                     })
//                     .catch(error=>{
//                         ctx.body = returns(-1, '服务器error1',error);
//                     })

//             })
//             .catch(async ()=>{
//                 await cartModel.create({uid: ctx.session.auth, pid, num:1})
//                     .then(data=>{
//                         ctx.body = returns(1, '添加到购物车成功', data);
//                     })
//                     .catch(error=>{
//                         ctx.body = returns(-1, '服务器error2',error);
//                     })
//             });
//     }
//     await next();
// });
// //当前用户删除购物车内商品
// router.delete('/api/cart', async (ctx, next)=>{
//     let {pid} = ctx.request.query;
//     if(pid){
//         await cartModel.findOne({uid: ctx.session.auth, pid})
//             .then( async data=>{
//                 if(data.num&&data.num>1){
//                     await cartModel.update({uid: ctx.session.auth, pid},{num: +data.num-1})
//                         .then(data=>{
//                             ctx.body = returns(1, '购物车delete成功', data);
//                         })
//                         .catch(error=>{
//                             ctx.body = returns(-1, '服务器error',error);
//                         })
//                 }else{
//                     await cartModel.remove({uid: ctx.session.auth, pid})
//                         .then(data=>{
//                             ctx.body = returns(1, '添加到购物车成功', data);
//                         })
//                         .catch(error=>{
//                             ctx.body = returns(-1, '服务器error',error);
//                         })
//                 }
//             })
//             .catch(error=>{
//                 ctx.body = returns(-1, '服务器错wu',error);
//             });
//         await next();
//     }
// });
// //当前用户更新购物车内数据
// //获取用户购物车数据
// router.post('/api/cart', async (ctx, next)=>{
//     if(ctx.session.auth){
//         await cartModel.find({uid: ctx.session.auth}).populate('pid')
//             .then(data=>{
//                 ctx.body = returns(1, '获取购物车数据成功', data);
//             })
//     }
//     await next();
// });
// //购物车商品选中状态更改
// router.get('/api/cart', async (ctx, next)=>{
//     let {cartid, checked} = ctx.request.query;
//     await cartModel.findOneAndUpdate({_id: mongoose.Types.ObjectId(cartid)},{checked})
//         .then(data=>{
//             ctx.body = returns(1, '选中状态更改成功', data);
//         })
//         .catch(error=>{
//             ctx.body = returns(-1, '选中状态更改失败');
//         });
//     await next();
// });
// //订单
// router.post('/api/order', async(ctx, next)=>{
//     let {cartids} = ctx.request.body;
//     if(cartids instanceof Array){
//         await cartModel.remove({_id:{$in:cartids.map((item)=>mongoose.Types.ObjectId(item.pid))}})
//             .then(data=>{
//                 console.log(data);
//             })
//             .catch(error=>{
//                 console.log(error);
//             });
//         await addrModel.find({_uid: mongoose.Types.ObjectId(ctx.session.auth)}).limit(1)
//             .then(async addr=>{
//                 await orderModel.create({orderProd:cartids,uid:ctx.session.auth, address: addr[0]})
//                     .then(data=>{
//                         console.log(data._id);
//                         ctx.body = returns(1, 'success', data);
//                     })
//                     .catch(error=>{
//                         ctx.body = returns(-1, 'error');
//                     })
//             })
//             .catch(()=>{
//                 ctx.body = returns(-1, '送货地址查询失败');
//             });
//     }
//     await next();
// });
// router.get('/api/order',async(ctx, next)=>{
//     let {payStatus} = ctx.request.query;
//     let queryObj = payStatus === undefined?{uid: ctx.session.auth}:{uid: ctx.session.auth,payStatus};
//     await  orderModel.find(queryObj)
//         .then(data=>{
//             ctx.body = returns(1, '获取订单数据成功',data);
//         })
//         .catch(error=>{
//             ctx.body = returns(-1,'error');
//         });
//     await next();
// });
// //结算---支付宝
// router.post('/api/accounts', async(ctx, next)=>{
//     let {orderid} = ctx.request.body;
//     await orderModel.findOne({_id: mongoose.Types.ObjectId(orderid)})
//         .then(data=>{
//             let allPrice = data.orderProd.reduce((prev, item)=>{
//                 return prev + +item.num * +item.price;
//             },0);
//             let pay_url = 'https://openapi.alipaydev.com/gateway.do?'+ali('点到商城收款',orderid,allPrice);
//             // console.log(pay_url);
//             ctx.body = returns(1,'ok', {pay_url})
//         })
//         .catch(error=>{
//             console.log(error);
//             ctx.body = returns(-1, '支付地址生成失败')
//         });
//     await next();
// });
// router.post('/paySuccess', async(ctx, next)=>{
//     // console.log(ctx.request.body);
//     let {out_trade_no} = ctx.request.body;
//     await orderModel.findOneAndUpdate({_id: mongoose.Types.ObjectId(out_trade_no)},{payStatus:1})
//         .then(data=>{
//             ctx.body = 'success';
//         });
//     await next();
// });
// /*管理员模块*/
// //管理员登录
// router.post('/api/admin', async (ctx, next)=>{
//     let {username, password} = ctx.request.body;
//     if(username&&password){
//         if(username === 'admin' && password === 'admin'){
//             ctx.body = returns(1, '欢迎登陆,admin');
//             ctx.session.admin = 'admin';
//         }else{
//             ctx.body = returns(-1, '账号或密码不正确');
//         }
//     }else{
//         ctx.body = returns(-1, '账号或密码不能为空')
//     }
//     await next();
// });
// /*管理员权限*/
// //增加商品
// router.put('/api/prod', async (ctx, next)=>{
//     let {prodType, prodImage, prodSupTitle, prodSubTitle, originPrice, currentPrice, sellCount, isPublish} = ctx.request.body;
//     await prodModel.create({
//         prodType,
//         prodImage,
//         prodSupTitle,
//         prodSubTitle,
//         originPrice,
//         currentPrice,
//         sellCount,
//         isPublish
//     }).then(data=>{
//         ctx.body = returns(1, '添加成功', data);
//     }).catch(error=>{
//         ctx.body = returns(-1, '写入数据库失败', error);
//     });
//     await next();
// });
// //删除商品
// router.delete('/api/prod', async (ctx, next)=>{
//     let _id = mongoose.Types.ObjectId(ctx.request.body.pid);
//     await prodModel.remove({_id}).then(data=>{
//         ctx.body = returns(1, '删除成功', data);
//     }).catch(error=>{
//         ctx.body = returns(-1, '删除失败', error);
//     });
//     await next();
// });
// //更新商品
// router.post('/api/prod', async (ctx, next)=>{
//     //商品上架
//     //商品下架
//     let {pid, isPublish} = ctx.request.body;
//     let msg = isPublish?"上架成功":"下架成功";
//     await prodModel.update({_id: mongoose.Types.ObjectId(pid)},{isPublish})
//         .then(data=>{
//             ctx.body = returns(1, msg, data);
//         })
//         .catch(()=>{
//             ctx.body = returns(-1, '失败');
//         });
//     await next();

// });
// //生成七牛云平台上传图片token,有效期2小时
// router.get('/api/qiniuToken',async (ctx, next)=>{
//     ctx.body = returns(1, '七牛token刷新', createToken());
//     await next();
// });
// //地址管理
// router.put('/api/addr', async(ctx, next)=>{
//     let {receiver, province, city, district, details, telNumber} = ctx.request.body;
//     await addrModel.create({receiver, province, city, district, details, telNumber, _uid: ctx.session.auth})
//         .then(data =>{
//             ctx.body = returns(1, '收货地址保存成功', data);
//         })
//         .catch(()=>{
//             ctx.body = returns(-1, '参数不正确' );
//         });
//     await next();
// });
// router.get('/api/addr', async(ctx, next)=>{
//     if(ctx.session.auth){
//         await addrModel.find({_uid: mongoose.Types.ObjectId(ctx.session.auth)})
//             .then(data=>{
//                 ctx.body = returns(1, '地址查询完成', data);
//             })
//             .catch(()=>{
//                 ctx.body = returns(-1, '数据库写入失败');
//             })
//     }else{
//         ctx.body = returns(-1, '没有权限');
//     }
//     await next();
// });
// router.delete('/api/addr', async(ctx, next)=>{
//     let {addrid} = ctx.request.query;
//     if(addrid){
//         await addrModel.remove({_id: mongoose.Types.ObjectId(addrid)})
//             .then(data=>{
//                 ctx.body = returns(1, '该地址删除成功', data)
//             })
//             .catch(()=>{
//                 ctx.body = returns(-1, '删除失败1,addrid不合法');
//             })
//     }else {
//         ctx.body = returns(-1, '删除失败2,addrid不合法');
//     }
//     await next();
// });









//导出模块
module.exports = router;
